Development Tools

Introduction

This section will review many of the popular development tools used to create component software on the Mac. We'll try to help you decide which tools should be used for which jobs. Subjects covered in this section include:

Decision Process provides guidance as to which development tools might be best for particular project.
Scenarios gives a couple of examples of making a decision about development tools.
C++ Development Environments introduces some of the popular systems used by Macintosh programmers.
C++ Utilities describes some extremely valuable tools for C++ programmers.
Java Tools introduces some tools used to create Java classes.
Frameworks and Libraries introduces some libraries and frameworks used to create components.
RAD Tools introduces some intriguing rapid applications development tools for building solutions.

Decision Process

There is a wide range of development tools becoming available for helping you create OpenDoc part editors and SOM libraries. Some of these tools have been shipping for years, while others are expected to ship in the coming months. If you are solving a complex customer problem, you may need to create a variety of part editors and libraries, and you may find yourself using many different development systems and tools. When you need to create a specific new part editor or library, you might use the information outlined below to decide which tools to use.

Features

First, you must decide on the features needed for a particular component. For example, the table above indicates that a Java applet will let you add behavior and a user interface, but has no support foe embedding other parts inside, or for linking data. As another example, a stand-alone SOM library can provide behavior or services, but has no user interface, and provides none of the other features usually associated with full OpenDoc parts. The chart indicates that the most full-featured component is probably an OpenDoc container part. It is no coincidence that creating this kind of component currently requires a relatively high level of programming skill.

Development Environments

The table above summarizes which development environments can be used for creating each type of component. Abbreviations are as follows:
- MPW is Apple's Macintosh Programmers Workshop.
- CW is Metrowerks CodeWarrior.
- RB is Symantec's C++ Development System (code-named Rainbow).
- AppWare is a visual RAD tool. system.
- Denali is Apple's RAD tool that uses Basic as a scripting language.
- Café is Symantec's Java Development System.
- WebBurst is a visual tool for building Java applets.

Notice that you can use either MPW, CodeWarrior, or Rainbow for creating most of these types of components. Which one should you use? They each have advantages, but we will admit that most OpenDoc developers seem to be using CodeWarrior these days. These tools are described in more detail below.

Frameworks and Libraries

The libraries and frameworks referred to above include:
- ODF. Apple's OpenDoc Development Framework.
- MacApp. Apple's applications framework.
- PowerParts. Metrowerks' framework for building leaf parts.
- Prograph CPX. Pictorius' applications framework.
- CCL. The Claris Container Library.
- OC. 6prime's Open Container library.
- ODIA. Apple's OpenDoc Internet Adapter library.

These libraries are described in more detail below.

Scenarios

Example 1: Simple OpenDoc leaf part.
In this case, you have at least three choices. First, you could use ODF, and write one set of source code used to compile a part editor for Mac and, soon, for Windows. Second, you could use PowerPart to create a part editor for the Mac. Third, you could code directly to the OpenDoc APIs. Which one should you choose? We'll go into that in more detail below, after we describe more about these tools.
Example 2: Container application.
You have a wide variety of choices. For example, if you have an existing application based on MacApp, then you would probably modify your code to work with the latest version of MacApp to inherit much of the container support. If you are converting an existing application written in Prograph, you should probably wait for container support to be added to the ABC's. With other applications, you can use a C-based library to help provide container support. The three libraries listed in the chart above are CCL, OC, and ODIA. All three are described in more detail below.

C++ Development Environments

CodeWarrior from Metrowerks. You can use this for programming in C, C++, and even Java. You can create SOM libraries and OpenDoc parts for either PowerPC or 68K processors. CodeWarrior is easy to learn to use, and has a fast compile/link cycle. It also has support for debugging, performance analysis, and plug-in tools for extensibility.
Rainbow from Symantec. Rainbow was the code name for the product. The official name is Symantec C++ for the Macintosh. This is a similar to CodeWarrior in many ways. One strength of Rainbow is that projects can have subprojects, which can be extremely valuable. Being able to open more than one project at a time allows you to work on your project while also opening a sample project from you which you can steal code snippets. You cannot do this with CodeWarrior. Rainbow has a nice integrated class browser, which is very valuable when working with class libraries and frameworks.
MPW from Apple. The Macintosh Programmers Workshop is Apple's primary development environment. Its virtues include: (1) Apple keeps it updated to support the latest system software, (2) all operations are fully scriptable with the built-in MPW scripting language, and (3) it tends to have very high quality compilers and linkers that generate optimized code that is small and fast.

C++ Utilities

AppMaker from Bowers Development is a visual resource editor and code generator that has specific support for programing with ODF.

You can use AppMaker to design the user interface for an OpenDoc part using simple mouse operations. From your design, AppMaker can generate either ODF or MacApp-style view resources, and also generate the code for a complete C++ program that will use these resources. If you need to create views with dialog items and controls, AppMaker will quickly pay for itself. Apple will be releasing other user interface design tools in the future, but AppMaker is shipping now.
Object Master from ACI US, Inc. is the most sophisticated code browser on the market. After parsing your source code, you can display many views of your code, including the tree view, browser views, or file views shown below.

File View

Tree View

Object Master is scriptable and can execute AppleScripts that you create. You can therefore use Object Master as the front end for all your development work. I.e., you can write your code in Object Master, and trigger compiles in Code Warrior, Rainbow, or MPW without leaving Object Master.
MacBrowse for ODF is an Apple browser provided free with ODF. It is not as full-featured as Object Master, but does offer two unique advantages. First, you can open multiple parse files at once, which you cannot do with Object Master. Second, you can parse SOM IDL files, which can be very useful when working with the OpenDoc APIs which are specified as IDL files.

Note that there is a version of MacBrowse that has shipped with MacApp for years. Do not use that version. The version you need for OpenDoc programming is the special version shipped with ODF.
The Debugger from Jasik Designs is the most powerful debugger available on the Macintosh. It is used by many applications developers, and many OpenDoc and ODF engineers.
PartMaker from Apple is used to copy and rename an existing project. This is extremely valuable, because OpenDoc projects are generally complex, with perhaps 20 or more source files, and many closely-related text strings and resources. The best way to begin any new OpenDoc part editor is to use PartMaker to make a copy of an existing project that compiles correctly. Developer releases of OpenDoc ship with PartMaker documents for replicating a variety of OpenDoc part editor samples - some written directly to the OpenDoc APIs, and some written with ODF. See the PartMaker ReadMe file for more information on using PartMaker.

A new, fancier version of PartMaker has been released under the name CodeSampler by 6prime corporation. Version 1.2 of CodeSampler can be found on the Cyberdog 1.0 CD-ROM, along with documents that can be used to create starter projects for building various Cyberdog part editors.

Java Tools

Café from Symantec is a development system specifically designed for writing Java code.
CodeWarrior from Metrowerks added support for Java programming in version DR 9.
Roaster from Natural Intelligence was the first Java development system for the Macintosh. Natural Intelligence has licensed some Java technology to Apple to be included in future versions of the Mac OS.
WebBurst from PowerProduction Software is an interactive Java applet builder. You can create dynamic applets using only the mouse and drag-and-drop; no Java language programming is required. Very cool.

Frameworks and Libraries

ODF is Apple's OpenDoc Development Framework. The architecture is described in the ODF architecture page on the web. ODF is a C++ framework for creating OpenDoc leaf parts and container parts. It includes a number of cross-platform libraries for 2D graphics, event handling, windows, menus, and so forth. You can use ODF to write a single source code base that can be compiled to create part editors for either the Mac OS or Windows 95 and Windows NT. There is also a possibility that IBM may make a version of ODF to support building part editors for OS/2 and AIX.

If you need to do cross-platform development and do not already have a large cross-platform code base, then you should probably develop your part editors using ODF. It is very well designed and supported, and provides the proper implementation of the standard recipes for OpenDoc programming. You will generally have much less code to write when using ODF, compared to writing parts directly to the OpenDoc APIs.

When should you use ODF? If you need to support the following features, ODF generally provides the simplest path to creating a part editor:
- Cross-platform source-code used for both Mac and Windows.
- Container parts.
- Linking.
- Scripting.
- Floating palettes.
- Easy support for Undo.
Apple's Developer University offers a five-day classroom-based course called "Creating OpenDoc Parts" that goes into detail on using ODF for creating part editors.
MacApp is Apple's mature applications framework. The latest release can be used to create OpenDoc container applications, although the support is still incomplete. MacApp provides an excellent basis for building a Macintosh application, with support for Apple technologies like scripting, drag-and-drop, and PowerTalk.
Claris Container Library was developed by Claris to support creating container applications. It is a modified and extended version of CALib, which Apple originally developed and shipped with earlier versions of OpenDoc.
OpenContent is a library for creating container applications, developed and supported by 6prime. Contact 6prime on the Web or via email for more information.
OpenDoc Internet Adapter (ODIA) is a new product being developed by Apple's OpenDoc team. It will provide a library to support creating container applications.
PowerParts. Metrowerks has added integrated support for building OpenDoc leaf parts to its standard PowerPlant applications framework. PowerParts provides a new PowerPart C++ base class, which you must subclass when creating a new part editor. The following features of PowerPlant are supported by PowerPart in CodeWarrior Gold release 9:
- LView hierarchies, created by a PPob resource
- LPane-based drawing and clicking
- most PowerPlant views and panes
- LCommander-based menu handling
- LListener-based communication
- LAction-based undo
- LDragAndDrop drop handling
- LDragTask drag initiating
- Movable modal dialogs, created by a PPob resource
- Floating palettes, created by a PPob resource
- LStream-based internalization and externalization

See the latest release of CodeWarrior or visit the Metrowerks Web site for more details.

RAD Tools

AppWare is an easy-to-use, component-based development tool for building double-clickable applications for Macintosh and Windows and Internet-based multimedia applets. AppWare components, known as AppWare Loadable Modules (ALMs), are "programmed" by graphically linking them together, as in a flow chart. Provided that you have the ALM's you need, you can use AppWare's visual dataflow programming language to assemble many applications in a few hours.

AppWare is planning support for creating OpenDoc parts in a future version. See Network Multimedia, Inc.'s Web site for the latest information.

Visual programming with AppWare

FaceSpan is a visual programming environment that allows you to quickly produce custom applications and prototypes. Using FaceSpan and AppleScript, Frontier, or any other OSA language, you can integrate off-the-shelf applications and scriptable OpenDoc parts into your own solutions. You create applications in FaceSpan by (1) creating a user interface using a visual interface builder, and (2) adding behavior to your user interface elements using a scripting language such as AppleScript. You can build useful applications in a few hours or less using FaceSpan, leveraging off existing scriptable applications and parts.

FaceSpan is planning support for creating OpenDoc parts in a future version. See Digital Technology International's Web site for the latest information.